
use crate::metadata::ir::*;
pub(crate) static REGISTERS: IR = IR {
    blocks: &[Block {
        name: "Hsem",
        extends: None,
        description: Some("Hardware semaphore."),
        items: &[
            BlockItem {
                name: "r",
                description: Some("HSEM register HSEM_R%s HSEM_R31."),
                array: Some(Array::Regular(RegularArray { len: 16, stride: 4 })),
                byte_offset: 0x0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("R"),
                }),
            },
            BlockItem {
                name: "rlr",
                description: Some("HSEM Read lock register."),
                array: Some(Array::Regular(RegularArray { len: 16, stride: 4 })),
                byte_offset: 0x80,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Rlr"),
                }),
            },
            BlockItem {
                name: "ier",
                description: Some("HSEM Interrupt enable register."),
                array: Some(Array::Regular(RegularArray { len: 1, stride: 16 })),
                byte_offset: 0x100,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Ier"),
                }),
            },
            BlockItem {
                name: "icr",
                description: Some("HSEM Interrupt clear register."),
                array: Some(Array::Regular(RegularArray { len: 1, stride: 16 })),
                byte_offset: 0x104,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Icr"),
                }),
            },
            BlockItem {
                name: "isr",
                description: Some("HSEM Interrupt status register."),
                array: Some(Array::Regular(RegularArray { len: 1, stride: 16 })),
                byte_offset: 0x108,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Isr"),
                }),
            },
            BlockItem {
                name: "misr",
                description: Some("HSEM Masked interrupt status register."),
                array: Some(Array::Regular(RegularArray { len: 1, stride: 16 })),
                byte_offset: 0x10c,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Misr"),
                }),
            },
            BlockItem {
                name: "cr",
                description: Some("HSEM Clear register."),
                array: None,
                byte_offset: 0x140,
                inner: BlockItemInner::Register(Register {
                    access: Access::Write,
                    bit_size: 32,
                    fieldset: Some("Cr"),
                }),
            },
            BlockItem {
                name: "keyr",
                description: Some("HSEM Interrupt clear register."),
                array: None,
                byte_offset: 0x144,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Keyr"),
                }),
            },
        ],
    }],
    fieldsets: &[
        FieldSet {
            name: "Cr",
            extends: None,
            description: Some("HSEM Clear register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "coreid",
                    description: Some("COREID."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "key",
                    description: Some("Semaphore clear Key."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 16,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Icr",
            extends: None,
            description: Some("HSEM Interrupt clear register."),
            bit_size: 32,
            fields: &[Field {
                name: "isc",
                description: Some("Interrupt(N) semaphore n clear bit."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 16, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ier",
            extends: None,
            description: Some("HSEM Interrupt enable register."),
            bit_size: 32,
            fields: &[Field {
                name: "ise",
                description: Some("Interrupt semaphore n enable bit."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 16, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Isr",
            extends: None,
            description: Some("HSEM Interrupt status register."),
            bit_size: 32,
            fields: &[Field {
                name: "isf",
                description: Some("Interrupt(N) semaphore n status bit before enable (mask)."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 16, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Keyr",
            extends: None,
            description: Some("HSEM Interrupt clear register."),
            bit_size: 32,
            fields: &[Field {
                name: "key",
                description: Some("Semaphore Clear Key."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                bit_size: 16,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Misr",
            extends: None,
            description: Some("HSEM Masked interrupt status register."),
            bit_size: 32,
            fields: &[Field {
                name: "misf",
                description: Some("masked interrupt(N) semaphore n status bit after enable (mask)."),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 1,
                array: Some(Array::Regular(RegularArray { len: 16, stride: 1 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "R",
            extends: None,
            description: Some("HSEM register HSEM_R%s HSEM_R31."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "procid",
                    description: Some("Semaphore ProcessID."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "coreid",
                    description: Some("Semaphore COREID."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "lock",
                    description: Some("Lock indication."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Rlr",
            extends: None,
            description: Some("HSEM Read lock register."),
            bit_size: 32,
            fields: &[
                Field {
                    name: "procid",
                    description: Some("Semaphore ProcessID."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 8,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "coreid",
                    description: Some("Semaphore COREID."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "lock",
                    description: Some("Lock indication."),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
    ],
    enums: &[],
};
